
import * as 引擎 from "./translator"
import { 系统 } from "../ctsUtils/sys"
import { 读词典数据, 插入词典数据 } from "../ctsUtils/loadDict";
import { 读注释缓存, 写注释缓存 } from "../ctsUtils/loadCommentCache";
import { 翻译注释文本 } from "./translateComment";
import { 标识符_, 译文_ } from "../ctsEnumsAndTypes/enumsAndTypes";
import { 是数组, 计算合格的标识符文本, 标识符或文本不需要翻译, 驼峰分割标识符, 多维重组 } from "../ctsUtils/utils";


export async function 翻译标识符(标识符: 标识符_) {
    if (!标识符.组成) {
        驼峰分割标识符(标识符);
    }
    let 库内存在 = 读词典数据(标识符);
    if (库内存在 && 库内存在.译文组) {
        return 库内存在;
    }
    else {
        return await 标识符分组翻译(标识符);
    }
}

export function 同步翻译注释(文本: string) {
    let 缓存键 = 系统.创建哈希(文本);
    let 库内内容 = 读注释缓存(缓存键);
    if (!库内内容) {
        return 文本;
    }
    else if (库内内容.length = 1) {
        return 库内内容[0];
    }
    else {

        let 基础长度 = 文本.length;
        let 数组 = 库内内容.sort((a, b) => {
            return Math.abs(a.length - 基础长度) - Math.abs(b.length - 基础长度);
        });

        return 数组[0];
    }

}

export async function 翻译注释(文本: string): Promise<string> {
    if (!文本) {
        return 文本;
    }

    let 缓存键 = 系统.创建哈希(文本);

    let 库内内容 = 读注释缓存(缓存键);

    if (!库内内容) {
        const 结果 = await 翻译注释文本(文本);
        写注释缓存(缓存键, 结果);
        return 结果;

    }
    else if (库内内容.length = 1) {
        return 库内内容[0];
    }
    else {

        let 基础长度 = 文本.length;

        let 数组 = 库内内容.sort((a, b) => {
            return Math.abs(a.length - 基础长度) - Math.abs(b.length - 基础长度);
        })

        return 数组[0];
    }

}

async function 标识符分组翻译(标识符: 标识符_) {
    let 分割组: 标识符_[] = 标识符.组成!;
    let 组索引: 标识符_[] = [];
    if (分割组) {
        for (let i = 0; i < 分割组.length; i++) {
            let 库内存在 = 读词典数据(分割组[i]);
            if (库内存在 && 库内存在.译文组) {
                分割组[i] = 库内存在;
            }
            else if (标识符或文本不需要翻译(分割组[i].原文)) {
                if (!分割组[i].译文组) {
                    分割组[i].译文组 = [{ 译文: 分割组[i].原文, 次数: 1 }];
                }
            }
            else {
                分割组[i] = await 翻译结果(分割组[i], 分割组[i].原文);
                插入词典数据(分割组[i]);
            }
            组索引.push(分割组[i]);
        }
    }
    let 翻译 = await 翻译结果(分割组 || 标识符, 标识符.原文);
    if (!标识符.译文组) 标识符.译文组 = 翻译.译文组;
    if (!标识符.组成) 标识符.组成 = 组索引;
    插入词典数据(标识符);
    return 标识符;
}

async function 翻译结果(单词: 标识符_ | 标识符_[], 原文: string): Promise<标识符_> {
    const 不翻译数组: 标识符_[] = [];
    const 需要翻译: string[][] = [];
    let 分块文本: string[] = [];
    if (!是数组(单词)) {
        if (单词.译文组) return 单词;
        let 分块主译 = 读词典数据({ 原文: 单词.原文 });
        if (!分块主译.译文组) {
            let 翻译块 = await 引擎.翻译器!(单词.原文);
            let 临时 = 分析单词翻译结果(翻译块 as 引擎.翻译结果, 单词.原文);
            if (临时) {
                单词.译文组 = 临时;
                return 单词;
            }
        }
        else {
            单词.译文组 = 分块主译.译文组;
            return 单词;
        }
        单词 = [单词];
    };
    let 分割文本组: string[] = [];

    for (let i = 0; i < 单词.length; i++) {
        if (标识符或文本不需要翻译(单词[i].原文)) {
            不翻译数组.push(单词[i]);
            if (分块文本.length) {
                需要翻译.push(分块文本);
                分块文本 = [];
            }
            需要翻译.push([]);
        }
        else {
            分块文本.push(单词[i].原文);
        }
        分割文本组.push(单词[i].原文);
    }

    if (不翻译数组.length) {
        if (分块文本.length) {
            需要翻译.push(分块文本);
        }
        let 译文组: 译文_[][] = [];
        let 不翻译索引 = 0;

        for (let vv of 需要翻译) {
            if (vv.length) {
                let 分块主译 = 读词典数据({ 原文: vv.join("") });
                if (!分块主译.译文组) {
                    let 翻译块 = await 引擎.翻译器!(vv);
                    let 临时 = 分析单词翻译结果(翻译块 as 引擎.翻译结果, vv.join(""));
                    译文组.push(临时!);
                }
                else {
                    译文组.push(分块主译.译文组!);
                }
            }
            else {
                译文组.push(不翻译数组[不翻译索引].译文组! || [{ 译文: 不翻译数组[不翻译索引].原文, 次数: 1 }]);
                不翻译索引++;
            }
        }

        let 组合主译: 标识符_ = {} as 标识符_;

        组合主译.原文 = 原文;
        组合主译.译文组 = 多维重组(译文组, 数组 => {
            return { 译文: 数组.map(v => v.译文).join(""), 次数: 1 };
        });
        return 组合主译;
    }

    let 库内主译 = 读词典数据({ 原文: 原文 });

    if (!库内主译.译文组) {
        let 主译 = await 引擎.翻译器!(分割文本组.join(" "));
        let 整体译文 = 分析单词翻译结果(主译 as 引擎.翻译结果, 原文);
        库内主译.译文组 = 整体译文 || [];
    }
    return 库内主译;

}

function 分析单词翻译结果(结果: 引擎.翻译结果, 原文: string) {
    if (!结果) {
        return;
    }
    let 译文组: 译文_[] = [];
    if (引擎.是百度结果(结果)) {
        let 数组值 = 结果.trans_result;
        if (数组值 && 数组值[0]) {
            数组值.forEach(值 => {
                let 译文: 译文_ = {} as 译文_;
                译文.译文 = 计算合格的标识符文本(值.dst, 原文);
                译文.次数 = 1;
                译文组.push(译文);
            });
        }
    }
    else if (引擎.是有道结果(结果)) {
        let 数组值 = 结果.translation;
        if (数组值 && 数组值.length > 0) {
            数组值.forEach(值 => {
                let 译文: 译文_ = {} as 译文_;
                译文.译文 = 计算合格的标识符文本(值, 原文);
                译文.次数 = 1;
                译文组.push(译文);
            });
        }
    }
    if (译文组.length) {
        return 译文组;
    }
    return;
}
